package com.estore.service;

import com.estore.model.Product;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 商品服务类，负责商品相关的业务逻辑
 * 目前使用内存Map模拟数据库
 */
public class ProductService {

    // 使用Map存储商品数据，key是商品ID，value是商品对象
    // 优点：通过ID查找商品时，时间复杂度是O(1)，非常高效
    private final Map<String, Product> productData = new HashMap<>();

    /**
     * 构造函数，初始化一些商品数据
     */
    public ProductService() {
        initializeSampleData();
    }

    /**
     * 初始化示例数据
     */
    private void initializeSampleData() {
        productData.put("p001", new Product("p001", "Java从入门到精通", 99.0, 100));
        productData.put("p002", new Product("p002", "高性能MySQL", 128.5, 50));
        productData.put("p003", new Product("p003", "颈椎康复指南", 45.0, 200));
        productData.put("p004", new Product("p004", "生发秘籍", 88.0, 0)); // 库存为0的商品
        productData.put("p005", new Product("p005", "设计模式之美", 79.9, 30));
        productData.put("p006", new Product("p006", "算法导论", 156.0, 25));
    }

    /**
     * 获取所有商品列表
     * @return 商品列表
     */
    public List<Product> getAllProducts() {
        return new ArrayList<>(productData.values());
    }

    /**
     * 根据ID查找商品
     * @param id 商品ID
     * @return 找到的商品对象，如果不存在则返回null
     */
    public Product findProductById(String id) {
        if (id == null || id.trim().isEmpty()) {
            throw new IllegalArgumentException("商品ID不能为空");
        }
        return productData.get(id.trim().toLowerCase());
    }

    /**
     * 添加新商品
     * @param product 商品对象
     * @return 添加成功返回true，如果商品ID已存在返回false
     */
    public boolean addProduct(Product product) {
        if (product == null) {
            throw new IllegalArgumentException("商品不能为空");
        }

        String id = product.getId().toLowerCase();
        if (productData.containsKey(id)) {
            return false;
        }

        productData.put(id, product);
        return true;
    }

    /**
     * 更新商品信息
     * @param product 商品对象
     * @return 更新成功返回true，如果商品不存在返回false
     */
    public boolean updateProduct(Product product) {
        if (product == null) {
            throw new IllegalArgumentException("商品不能为空");
        }

        String id = product.getId().toLowerCase();
        if (!productData.containsKey(id)) {
            return false;
        }

        productData.put(id, product);
        return true;
    }

    /**
     * 删除商品
     * @param id 商品ID
     * @return 删除成功返回true，如果商品不存在返回false
     */
    public boolean deleteProduct(String id) {
        if (id == null || id.trim().isEmpty()) {
            throw new IllegalArgumentException("商品ID不能为空");
        }

        return productData.remove(id.trim().toLowerCase()) != null;
    }

    /**
     * 根据名称搜索商品（模糊匹配）
     * @param name 商品名称关键词
     * @return 匹配的商品列表
     */
    public List<Product> searchProductsByName(String name) {
        if (name == null || name.trim().isEmpty()) {
            return new ArrayList<>();
        }

        String keyword = name.trim().toLowerCase();
        return productData.values().stream()
                .filter(product -> product.getName().toLowerCase().contains(keyword))
                .collect(Collectors.toList());
    }

    /**
     * 获取有库存的商品列表
     * @return 有库存的商品列表
     */
    public List<Product> getAvailableProducts() {
        return productData.values().stream()
                .filter(Product::isInStock)
                .collect(Collectors.toList());
    }

    /**
     * 获取缺货的商品列表
     * @return 缺货的商品列表
     */
    public List<Product> getOutOfStockProducts() {
        return productData.values().stream()
                .filter(product -> !product.isInStock())
                .collect(Collectors.toList());
    }

    /**
     * 根据价格范围筛选商品
     * @param minPrice 最低价格
     * @param maxPrice 最高价格
     * @return 价格范围内的商品列表
     */
    public List<Product> getProductsByPriceRange(double minPrice, double maxPrice) {
        if (minPrice < 0 || maxPrice < 0 || minPrice > maxPrice) {
            throw new IllegalArgumentException("价格范围无效");
        }

        return productData.values().stream()
                .filter(product -> product.getPrice() >= minPrice && product.getPrice() <= maxPrice)
                .collect(Collectors.toList());
    }

    /**
     * 减少商品库存
     * @param id 商品ID
     * @param quantity 减少的数量
     * @return 减少成功返回true，库存不足或商品不存在返回false
     */
    public boolean decreaseStock(String id, int quantity) {
        Product product = findProductById(id);
        if (product == null) {
            return false;
        }

        return product.decreaseStock(quantity);
    }

    /**
     * 增加商品库存
     * @param id 商品ID
     * @param quantity 增加的数量
     * @return 增加后的库存数量，如果商品不存在返回-1
     */
    public int increaseStock(String id, int quantity) {
        Product product = findProductById(id);
        if (product == null) {
            return -1;
        }

        return product.increaseStock(quantity);
    }

    /**
     * 检查商品库存是否充足
     * @param id 商品ID
     * @param quantity 需要检查的数量
     * @return 库存充足返回true，否则返回false
     */
    public boolean isStockSufficient(String id, int quantity) {
        Product product = findProductById(id);
        if (product == null) {
            return false;
        }

        return product.isStockSufficient(quantity);
    }

    /**
     * 获取商品总数
     * @return 商品总数
     */
    public int getTotalProductCount() {
        return productData.size();
    }

    /**
     * 获取有库存的商品数量
     * @return 有库存的商品数量
     */
    public int getAvailableProductCount() {
        return (int) productData.values().stream()
                .filter(Product::isInStock)
                .count();
    }

    /**
     * 清空所有商品数据（用于测试或重置）
     */
    public void clearAllProducts() {
        productData.clear();
    }

    /**
     * 批量添加商品
     * @param products 商品列表
     * @return 成功添加的商品数量
     */
    public int addProducts(List<Product> products) {
        if (products == null || products.isEmpty()) {
            return 0;
        }

        int count = 0;
        for (Product product : products) {
            if (addProduct(product)) {
                count++;
            }
        }
        return count;
    }

    /**
     * 获取最贵的商品
     * @return 最贵的商品，如果没有商品返回null
     */
    public Product getMostExpensiveProduct() {
        return productData.values().stream()
                .max((p1, p2) -> Double.compare(p1.getPrice(), p2.getPrice()))
                .orElse(null);
    }

    /**
     * 获取最便宜的商品
     * @return 最便宜的商品，如果没有商品返回null
     */
    public Product getCheapestProduct() {
        return productData.values().stream()
                .min((p1, p2) -> Double.compare(p1.getPrice(), p2.getPrice()))
                .orElse(null);
    }

    /**
     * 获取所有商品的总价值（价格 × 库存）
     * @return 总价值
     */
    public double getTotalInventoryValue() {
        return productData.values().stream()
                .mapToDouble(product -> product.getPrice() * product.getStock())
                .sum();
    }

    /**
     * 根据库存数量排序获取商品列表
     * @param ascending 是否升序排列
     * @return 排序后的商品列表
     */
    public List<Product> getProductsSortedByStock(boolean ascending) {
        return productData.values().stream()
                .sorted((p1, p2) -> ascending ?
                        Integer.compare(p1.getStock(), p2.getStock()) :
                        Integer.compare(p2.getStock(), p1.getStock()))
                .collect(Collectors.toList());
    }

    /**
     * 根据价格排序获取商品列表
     * @param ascending 是否升序排列
     * @return 排序后的商品列表
     */
    public List<Product> getProductsSortedByPrice(boolean ascending) {
        return productData.values().stream()
                .sorted((p1, p2) -> ascending ?
                        Double.compare(p1.getPrice(), p2.getPrice()) :
                        Double.compare(p2.getPrice(), p1.getPrice()))
                .collect(Collectors.toList());
    }

    /**
     * 检查商品是否存在
     * @param id 商品ID
     * @return 存在返回true，否则返回false
     */
    public boolean productExists(String id) {
        if (id == null || id.trim().isEmpty()) {
            return false;
        }
        return productData.containsKey(id.trim().toLowerCase());
    }

    /**
     * 获取商品统计信息
     * @return 统计信息字符串
     */
    public String getStatistics() {
        int totalProducts = getTotalProductCount();
        int availableProducts = getAvailableProductCount();
        int outOfStockProducts = totalProducts - availableProducts;
        double totalValue = getTotalInventoryValue();
        Product mostExpensive = getMostExpensiveProduct();
        Product cheapest = getCheapestProduct();

        return String.format(
                "商品统计信息:\n" +
                        "总商品数: %d\n" +
                        "有库存商品: %d\n" +
                        "缺货商品: %d\n" +
                        "库存总价值: ¥%.2f\n" +
                        "最贵商品: %s (¥%.2f)\n" +
                        "最便宜商品: %s (¥%.2f)",
                totalProducts, availableProducts, outOfStockProducts, totalValue,
                mostExpensive != null ? mostExpensive.getName() : "无",
                mostExpensive != null ? mostExpensive.getPrice() : 0,
                cheapest != null ? cheapest.getName() : "无",
                cheapest != null ? cheapest.getPrice() : 0
        );
    }
}